Premium Content

DJANGO FUNDAMENTALS

Learn the core concepts of Django web framework

Beginner

Module 1: Django Fundamentals

Django is a high-level Python web framework that enables rapid development of secure and maintainable websites. Built by experienced developers, Django takes care of much of the hassle of web development, so you can focus on writing your app without needing to reinvent the wheel.

Try It Yourself:

Python Code

# Django Project Setup
# First, install Django (run in terminal):
# pip install django

# Create a new Django project:
# django-admin startproject myproject

# Navigate to project directory:
# cd myproject

# Create a new app:
# python manage.py startapp myapp

# Basic project structure:
# myproject/
# ├── manage.py
# ├── myproject/
# │   ├── __init__.py
# │   ├── settings.py
# │   ├── urls.py
# │   └── wsgi.py
# └── myapp/
#     ├── __init__.py
#     ├── admin.py
#     ├── apps.py
#     ├── models.py
#     ├── tests.py
#     ├── views.py
#     └── urls.py

# Sample settings.py configuration
"""
Django settings for myproject project.

Generated by 'django-admin startproject' using Django 4.2.

For more information on this file, see
https://docs.djangoproject.com/en/4.2/topics/settings/

For the full list of settings and their values, see
https://docs.djangoproject.com/en/4.2/ref/settings/
"""

import os
from pathlib import Path

# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'your-secret-key-here'

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

ALLOWED_HOSTS = []

# Application definition
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'myapp',  # Your custom app
]

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

ROOT_URLCONF = 'myproject.urls'

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [BASE_DIR / 'templates'],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

WSGI_APPLICATION = 'myproject.wsgi.application'

# Database
# https://docs.djangoproject.com/en/4.2/ref/settings/#databases
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

# Password validation
# https://docs.djangoproject.com/en/4.2/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
    {
        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
    },
]

# Internationalization
# https://docs.djangoproject.com/en/4.2/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_TZ = True

# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/4.2/howto/static-files/
STATIC_URL = 'static/'
STATICFILES_DIRS = [BASE_DIR / 'static']

# Default primary key field type
# https://docs.djangoproject.com/en/4.2/ref/settings/#default-auto-field
DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'

# Run the development server:
# python manage.py runserver

Code Analysis

This Django setup demonstrates:

Project Structure: Django follows MVT (Model-View-Template) architecture
Settings Configuration: Central configuration for the entire project
Apps: Django projects are composed of reusable applications
Database Setup: Default SQLite configuration for development
Security Features: Built-in password validation and security middleware
Static Files: Configuration for CSS, JavaScript, and images

Key Takeaway: Django provides a robust foundation with sensible defaults, allowing developers to focus on application logic rather than configuration.

Key Django Concepts:

MVT Pattern - Model-View-Template architecture
Projects vs Apps - Projects contain multiple apps
URL Routing - Clean URL patterns with regex support
ORM - Database abstraction layer
Admin Interface - Automatic admin interface
Middleware - Request/response processing hooks
Security - Built-in protection against common vulnerabilities

Premium Content

DJANGO MODELS

Master Django's Object-Relational Mapping system

Beginner

Module 2: Django Models and Database

Django's Object-Relational Mapping (ORM) system allows you to interact with your database using Python code instead of SQL. Models define the structure of your database tables, and Django automatically generates the database schema from your model definitions.

Try It Yourself:

Python Code

# Django Models Example
# In your app's models.py file

from django.db import models
from django.contrib.auth.models import User
from django.urls import reverse
from django.utils import timezone

# Category model
class Category(models.Model):
    name = models.CharField(max_length=100)
    description = models.TextField(blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    
    class Meta:
        verbose_name_plural = "Categories"
        ordering = ['name']
    
    def __str__(self):
        return self.name

# Post model with various field types
class Post(models.Model):
    # Choice field for post status
    STATUS_CHOICES = [
        ('draft', 'Draft'),
        ('published', 'Published'),
        ('archived', 'Archived'),
    ]
    
    title = models.CharField(max_length=200)
    slug = models.SlugField(unique=True, max_length=200)
    content = models.TextField()
    excerpt = models.TextField(max_length=300, blank=True)
    
    # Foreign Key relationship to User model
    author = models.ForeignKey(
        User, 
        on_delete=models.CASCADE,
        related_name='blog_posts'
    )
    
    # Many-to-Many relationship with Category
    categories = models.ManyToManyField(Category, related_name='posts')
    
    # Status field with choices
    status = models.CharField(
        max_length=10,
        choices=STATUS_CHOICES,
        default='draft'
    )
    
    # Date fields
    published_date = models.DateTimeField(null=True, blank=True)
    created_date = models.DateTimeField(auto_now_add=True)
    updated_date = models.DateTimeField(auto_now=True)
    
    # Image field
    featured_image = models.ImageField(
        upload_to='blog/images/',
        null=True,
        blank=True
    )
    
    class Meta:
        ordering = ['-published_date']
        indexes = [
            models.Index(fields=['-published_date']),
        ]
    
    def __str__(self):
        return self.title
    
    def get_absolute_url(self):
        return reverse('post_detail', args=[self.slug])
    
    def save(self, *args, **kwargs):
        if self.status == 'published' and not self.published_date:
            self.published_date = timezone.now()
        super().save(*args, **kwargs)

# Comment model with custom methods
class Comment(models.Model):
    post = models.ForeignKey(
        Post,
        on_delete=models.CASCADE,
        related_name='comments'
    )
    author = models.CharField(max_length=100)
    email = models.EmailField()
    content = models.TextField()
    created_date = models.DateTimeField(auto_now_add=True)
    approved = models.BooleanField(default=False)
    
    class Meta:
        ordering = ['created_date']
    
    def __str__(self):
        return f'Comment by {self.author} on {self.post.title}'
    
    def approve(self):
        self.approved = True
        self.save()

# Using the models in views or shell
"""
# Create and save objects
category = Category(name="Technology", description="Tech-related posts")
category.save()

# Or use create() method
post = Post.objects.create(
    title="My First Post",
    slug="my-first-post",
    content="This is the content of my first post.",
    author=user_instance,  # Assuming you have a user instance
    status="published"
)

# Add categories to post (many-to-many)
post.categories.add(category)

# Query examples
published_posts = Post.objects.filter(status='published')
recent_posts = Post.objects.filter(
    published_date__gte=timezone.now() - timezone.timedelta(days=7)
)
tech_posts = Post.objects.filter(categories__name='Technology')

# Update objects
post.title = "Updated Title"
post.save()

# Delete objects
post.delete()
"""

Model Analysis

This Django models example demonstrates:

Model Definition: Creating database tables as Python classes
Field Types: Various field types (CharField, TextField, DateTimeField, etc.)
Relationships: ForeignKey and ManyToManyField for table relationships
Model Methods: Custom methods like save() and get_absolute_url()
Meta Options: Database table configuration like ordering and indexes
Query API: Using Django's ORM to interact with the database

Key Takeaway: Django's ORM provides a Pythonic way to interact with databases, eliminating the need to write raw SQL while maintaining performance and flexibility.

Django Model Features:

Field Types - Various data types with validation
Relationships - One-to-one, one-to-many, many-to-many
Model Methods - Custom business logic in models
QuerySet API - Powerful database query interface
Migrations - Version control for database schema
Model Admin - Automatic admin interface for models
Validation - Data validation at model level
Signals - Event-driven programming with models

Premium Content

VIEWS & URLS

Handle requests and define URL patterns

Intermediate

Module 3: Django Views and URL Configuration

Django views are Python functions or classes that receive web requests and return web responses. URL patterns map URLs to views, creating the routing system for your web application. Understanding views and URLs is crucial for building functional Django applications.

Try It Yourself:

Python Code

# Django Views and URLs Examples
# In your app's views.py file

from django.shortcuts import render, get_object_or_404, redirect
from django.http import HttpResponse, JsonResponse, Http404
from django.views import View
from django.views.generic import ListView, DetailView, CreateView, UpdateView, DeleteView
from django.contrib.auth.mixins import LoginRequiredMixin
from django.contrib import messages
from django.urls import reverse_lazy
from django.utils.decorators import method_decorator
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_http_methods
from .models import Post, Category, Comment
from .forms import PostForm, CommentForm

# Function-based views
def post_list(request):
    """Display a list of published posts"""
    posts = Post.objects.filter(status='published').order_by('-published_date')
    categories = Category.objects.all()
    
    context = {
        'posts': posts,
        'categories': categories,
        'page_title': 'Latest Posts'
    }
    return render(request, 'blog/post_list.html', context)

def post_detail(request, slug):
    """Display a single post with comments"""
    post = get_object_or_404(Post, slug=slug, status='published')
    comments = post.comments.filter(approved=True)
    
    # Handle comment submission
    if request.method == 'POST':
        comment_form = CommentForm(request.POST)
        if comment_form.is_valid():
            comment = comment_form.save(commit=False)
            comment.post = post
            comment.save()
            messages.success(request, 'Your comment has been submitted for approval.')
            return redirect('post_detail', slug=slug)
    else:
        comment_form = CommentForm()
    
    context = {
        'post': post,
        'comments': comments,
        'comment_form': comment_form,
    }
    return render(request, 'blog/post_detail.html', context)

# Class-based views
class PostListView(ListView):
    """Class-based view for post list"""
    model = Post
    template_name = 'blog/post_list.html'
    context_object_name = 'posts'
    paginate_by = 10
    
    def get_queryset(self):
        return Post.objects.filter(status='published').order_by('-published_date')
    
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['categories'] = Category.objects.all()
        context['page_title'] = 'Latest Posts'
        return context

class PostDetailView(DetailView):
    """Class-based view for post detail"""
    model = Post
    template_name = 'blog/post_detail.html'
    context_object_name = 'post'
    
    def get_queryset(self):
        return Post.objects.filter(status='published')
    
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['comments'] = self.object.comments.filter(approved=True)
        context['comment_form'] = CommentForm()
        return context

# Create, Update, Delete views with authentication
class PostCreateView(LoginRequiredMixin, CreateView):
    """View for creating new posts"""
    model = Post
    form_class = PostForm
    template_name = 'blog/post_form.html'
    success_url = reverse_lazy('post_list')
    
    def form_valid(self, form):
        form.instance.author = self.request.user
        messages.success(self.request, 'Post created successfully!')
        return super().form_valid(form)

class PostUpdateView(LoginRequiredMixin, UpdateView):
    """View for updating existing posts"""
    model = Post
    form_class = PostForm
    template_name = 'blog/post_form.html'
    
    def get_queryset(self):
        return Post.objects.filter(author=self.request.user)
    
    def form_valid(self, form):
        messages.success(self.request, 'Post updated successfully!')
        return super().form_valid(form)

class PostDeleteView(LoginRequiredMixin, DeleteView):
    """View for deleting posts"""
    model = Post
    template_name = 'blog/post_confirm_delete.html'
    success_url = reverse_lazy('post_list')
    
    def get_queryset(self):
        return Post.objects.filter(author=self.request.user)
    
    def delete(self, request, *args, **kwargs):
        messages.success(request, 'Post deleted successfully!')
        return super().delete(request, *args, **kwargs)

# API views for AJAX requests
@require_http_methods(["GET"])
def category_posts_api(request, category_id):
    """API endpoint to get posts by category"""
    try:
        category = Category.objects.get(id=category_id)
        posts = category.posts.filter(status='published').values(
            'id', 'title', 'slug', 'published_date'
        )
        return JsonResponse(list(posts), safe=False)
    except Category.DoesNotExist:
        return JsonResponse({'error': 'Category not found'}, status=404)

@csrf_exempt
@require_http_methods(["POST"])
def like_post_api(request, post_id):
    """API endpoint to like a post"""
    if request.method == 'POST':
        try:
            post = Post.objects.get(id=post_id)
            # Implement like logic here
            return JsonResponse({'success': True, 'likes': post.likes_count})
        except Post.DoesNotExist:
            return JsonResponse({'error': 'Post not found'}, status=404)

# URL Configuration (urls.py)
"""
from django.urls import path, include
from . import views

app_name = 'blog'

urlpatterns = [
    # Function-based views
    path('', views.post_list, name='post_list'),
    path('post/<slug:slug>/', views.post_detail, name='post_detail'),
    
    # Class-based views
    path('posts/', views.PostListView.as_view(), name='post_list_cbv'),
    path('post/<int:pk>/', views.PostDetailView.as_view(), name='post_detail_cbv'),
    
    # CRUD operations
    path('post/new/', views.PostCreateView.as_view(), name='post_create'),
    path('post/<int:pk>/edit/', views.PostUpdateView.as_view(), name='post_update'),
    path('post/<int:pk>/delete/', views.PostDeleteView.as_view(), name='post_delete'),
    
    # API endpoints
    path('api/category/<int:category_id>/posts/', views.category_posts_api, name='category_posts_api'),
    path('api/post/<int:post_id>/like/', views.like_post_api, name='like_post_api'),
]
"""

Views & URLs Analysis

This Django views and URLs example demonstrates:

Function-based Views: Simple views as Python functions
Class-based Views: Reusable view classes with built-in functionality
Generic Views: Pre-built views for common patterns (List, Detail, Create, Update, Delete)
Authentication: Using mixins to require login
URL Patterns: Mapping URLs to views with parameters
API Views: Creating endpoints for AJAX requests
Message Framework: User feedback with Django's messaging system

Key Takeaway: Django provides multiple approaches to creating views, from simple function-based views to powerful class-based views, allowing developers to choose the right tool for each task.

Django Views & URLs Features:

Function-based Views - Simple, straightforward view functions
Class-based Views - Reusable, extensible view classes
Generic Views - Pre-built views for common patterns
URL Routing - Clean URL patterns with parameter capture
Request/Response - Handling HTTP requests and responses
Decorators - Adding functionality to views
Mixins - Reusable view components
API Endpoints - Creating RESTful API views

Premium Content

DJANGO TEMPLATES

Create dynamic HTML with Django template language

Intermediate

Module 4: Django Templates and Frontend

Django's template system allows you to create dynamic HTML pages with a simple, yet powerful language. Templates separate presentation from business logic, making your code more maintainable. Django templates support inheritance, filters, tags, and context variables.

Try It Yourself:

HTML/Django Template

<!-- Base Template (base.html) -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{% block title %}My Django Blog{% endblock %}</title>
    
    <!-- Bootstrap CSS -->
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
    
    <!-- Custom CSS -->
    <style>
        .navbar-brand {
            font-weight: bold;
        }
        .post-card {
            transition: transform 0.2s;
        }
        .post-card:hover {
            transform: translateY(-5px);
        }
        .category-badge {
            font-size: 0.8rem;
        }
    </style>
    
    {% block extra_css %}{% endblock %}
</head>
<body>
    <!-- Navigation -->
    <nav class="navbar navbar-expand-lg navbar-dark bg-dark">
        <div class="container">
            <a class="navbar-brand" href="{% url 'post_list' %}">Django Blog</a>
            
            <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarNav">
                <span class="navbar-toggler-icon"></span>
            </button>
            
            <div class="collapse navbar-collapse" id="navbarNav">
                <ul class="navbar-nav me-auto">
                    <li class="nav-item">
                        <a class="nav-link" href="{% url 'post_list' %}">Home</a>
                    </li>
                    <li class="nav-item dropdown">
                        <a class="nav-link dropdown-toggle" href="#" role="button" data-bs-toggle="dropdown">
                            Categories
                        </a>
                        <ul class="dropdown-menu">
                            {% for category in categories %}
                                <li>
                                    <a class="dropdown-item" href="{% url 'category_posts' category.slug %}">
                                        {{ category.name }}
                                    </a>
                                </li>
                            {% empty %}
                                <li><span class="dropdown-item-text">No categories</span></li>
                            {% endfor %}
                        </ul>
                    </li>
                </ul>
                
                <!-- User authentication links -->
                <ul class="navbar-nav">
                    {% if user.is_authenticated %}
                        <li class="nav-item dropdown">
                            <a class="nav-link dropdown-toggle" href="#" role="button" data-bs-toggle="dropdown">
                                {{ user.username }}
                            </a>
                            <ul class="dropdown-menu">
                                <li><a class="dropdown-item" href="{% url 'post_create' %}">New Post</a></li>
                                <li><hr class="dropdown-divider"></li>
                                <li><a class="dropdown-item" href="{% url 'logout' %}">Logout</a></li>
                            </ul>
                        </li>
                    {% else %}
                        <li class="nav-item">
                            <a class="nav-link" href="{% url 'login' %}">Login</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link" href="{% url 'register' %}">Register</a>
                        </li>
                    {% endif %}
                </ul>
            </div>
        </div>
    </nav>

    <!-- Main Content -->
    <main class="container my-4">
        <!-- Messages -->
        {% if messages %}
            <div class="messages">
                {% for message in messages %}
                    <div class="alert alert-{{ message.tags }} alert-dismissible fade show" role="alert">
                        {{ message }}
                        <button type="button" class="btn-close" data-bs-dismiss="alert"></button>
                    </div>
                {% endfor %}
            </div>
        {% endif %}

        <!-- Page Title -->
        {% if page_title %}
            <h1 class="mb-4">{{ page_title }}</h1>
        {% endif %}

        <!-- Content Block -->
        {% block content %}
        {% endblock %}
    </main>

    <!-- Footer -->
    <footer class="bg-dark text-light py-4 mt-5">
        <div class="container text-center">
            <p>© 2023 Django Blog. All rights reserved.</p>
        </div>
    </footer>

    <!-- Bootstrap JS -->
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
    
    {% block extra_js %}{% endblock %}
</body>
</html>

<!-- Post List Template (post_list.html) -->
{% extends 'base.html' %}
{% load static %}

{% block title %}Latest Posts - {{ block.super }}{% endblock %}

{% block content %}
<div class="row">
    <!-- Main Content -->
    <div class="col-lg-8">
        {% if posts %}
            {% for post in posts %}
                <div class="card post-card mb-4">
                    {% if post.featured_image %}
                        <img src="{{ post.featured_image.url }}" class="card-img-top" alt="{{ post.title }}">
                    {% endif %}
                    
                    <div class="card-body">
                        <h2 class="card-title">
                            <a href="{% url 'post_detail' post.slug %}" class="text-decoration-none">
                                {{ post.title }}
                            </a>
                        </h2>
                        
                        <p class="text-muted">
                            Posted by {{ post.author.username }} on 
                            {{ post.published_date|date:"F j, Y" }}
                        </p>
                        
                        <p class="card-text">
                            {% if post.excerpt %}
                                {{ post.excerpt }}
                            {% else %}
                                {{ post.content|truncatewords:30 }}
                            {% endif %}
                        </p>
                        
                        <div class="d-flex justify-content-between align-items-center">
                            <a href="{% url 'post_detail' post.slug %}" class="btn btn-primary">
                                Read More
                            </a>
                            
                            <div>
                                {% for category in post.categories.all %}
                                    <span class="badge bg-secondary category-badge me-1">
                                        {{ category.name }}
                                    </span>
                                {% endfor %}
                            </div>
                        </div>
                    </div>
                </div>
            {% endfor %}
            
            <!-- Pagination -->
            {% if is_paginated %}
                <nav aria-label="Page navigation">
                    <ul class="pagination justify-content-center">
                        {% if page_obj.has_previous %}
                            <li class="page-item">
                                <a class="page-link" href="?page={{ page_obj.previous_page_number }}">Previous</a>
                            </li>
                        {% endif %}
                        
                        {% for num in page_obj.paginator.page_range %}
                            {% if page_obj.number == num %}
                                <li class="page-item active">
                                    <span class="page-link">{{ num }}</span>
                                </li>
                            {% else %}
                                <li class="page-item">
                                    <a class="page-link" href="?page={{ num }}">{{ num }}</a>
                                </li>
                            {% endif %}
                        {% endfor %}
                        
                        {% if page_obj.has_next %}
                            <li class="page-item">
                                <a class="page-link" href="?page={{ page_obj.next_page_number }}">Next</a>
                            </li>
                        {% endif %}
                    </ul>
                </nav>
            {% endif %}
            
        {% else %}
            <div class="alert alert-info">
                <h4>No posts available</h4>
                <p>There are no published posts at the moment.</p>
            </div>
        {% endif %}
    </div>
    
    <!-- Sidebar -->
    <div class="col-lg-4">
        <div class="card mb-4">
            <div class="card-header">
                <h5>Categories</h5>
            </div>
            <div class="card-body">
                <ul class="list-unstyled">
                    {% for category in categories %}
                        <li class="mb-2">
                            <a href="{% url 'category_posts' category.slug %}" class="text-decoration-none">
                                {{ category.name }} 
                                <span class="badge bg-primary rounded-pill">
                                    {{ category.posts.count }}
                                </span>
                            </a>
                        </li>
                    {% empty %}
                        <li>No categories available</li>
                    {% endfor %}
                </ul>
            </div>
        </div>
        
        <div class="card">
            <div class="card-header">
                <h5>About</h5>
            </div>
            <div class="card-body">
                <p>Welcome to our Django blog! Here you'll find the latest posts about web development, programming, and technology.</p>
            </div>
        </div>
    </div>
</div>
{% endblock %}

Template Analysis

This Django template example demonstrates:

Template Inheritance: Using extends to create reusable base templates
Blocks: Defining content areas that child templates can override
Template Tags: Using Django's built-in tags for logic and control flow
Filters: Modifying variable output with filters like date and truncatewords
URL Reversal: Generating URLs with the url template tag
Conditional Logic: Using if/else statements in templates
Loops: Iterating through lists with for loops
Pagination: Implementing pagination for lists of objects

Key Takeaway: Django's template system provides a powerful way to create dynamic HTML while keeping presentation logic separate from business logic, following the DRY (Don't Repeat Yourself) principle.

Django Template Features:

Template Inheritance - Create reusable base templates
Template Tags - Built-in tags for logic and control flow
Filters - Modify variable output in templates
Context Variables - Pass data from views to templates
Template Includes - Reuse template fragments
Static Files - Manage CSS, JavaScript, and images
Custom Tags/Filters - Extend template functionality
Template Caching - Improve performance with caching

Premium Content

AUTHENTICATION & ADMIN

Implement user authentication and admin interface

Intermediate

Module 5: Django Authentication and Admin

Django provides a robust authentication system out of the box, including user accounts, groups, permissions, and cookie-based sessions. The Django admin interface is a powerful tool for managing your application's data, automatically generated from your models.

Try It Yourself:

Python Code

# Django Authentication and Admin Examples
# Custom User Model (models.py)
from django.contrib.auth.models import AbstractUser
from django.db import models

class CustomUser(AbstractUser):
    # Additional fields
    bio = models.TextField(max_length=500, blank=True)
    location = models.CharField(max_length=30, blank=True)
    birth_date = models.DateField(null=True, blank=True)
    profile_picture = models.ImageField(
        upload_to='profile_pics/',
        null=True,
        blank=True
    )
    
    # Social media fields
    website = models.URLField(blank=True)
    twitter = models.CharField(max_length=30, blank=True)
    github = models.CharField(max_length=30, blank=True)
    
    def __str__(self):
        return self.username

# Update settings.py to use custom user model
"""
AUTH_USER_MODEL = 'myapp.CustomUser'
"""

# User Registration Form (forms.py)
from django import forms
from django.contrib.auth.forms import UserCreationForm
from .models import CustomUser

class CustomUserCreationForm(UserCreationForm):
    email = forms.EmailField(required=True)
    
    class Meta:
        model = CustomUser
        fields = ('username', 'email', 'password1', 'password2')
    
    def save(self, commit=True):
        user = super().save(commit=False)
        user.email = self.cleaned_data['email']
        if commit:
            user.save()
        return user

# User Profile Form
class UserProfileForm(forms.ModelForm):
    class Meta:
        model = CustomUser
        fields = ('first_name', 'last_name', 'email', 'bio', 'location', 
                 'birth_date', 'website', 'twitter', 'github')
        widgets = {
            'birth_date': forms.DateInput(attrs={'type': 'date'}),
            'bio': forms.Textarea(attrs={'rows': 4}),
        }

# Authentication Views (views.py)
from django.contrib.auth import login, authenticate, update_session_auth_hash
from django.contrib.auth.forms import AuthenticationForm, PasswordChangeForm
from django.contrib.auth.decorators import login_required
from django.shortcuts import render, redirect
from django.contrib import messages
from .forms import CustomUserCreationForm, UserProfileForm

def register(request):
    """User registration view"""
    if request.method == 'POST':
        form = CustomUserCreationForm(request.POST)
        if form.is_valid():
            user = form.save()
            login(request, user)
            messages.success(request, 'Registration successful!')
            return redirect('home')
    else:
        form = CustomUserCreationForm()
    
    return render(request, 'auth/register.html', {'form': form})

def user_login(request):
    """User login view"""
    if request.method == 'POST':
        form = AuthenticationForm(request, data=request.POST)
        if form.is_valid():
            username = form.cleaned_data.get('username')
            password = form.cleaned_data.get('password')
            user = authenticate(username=username, password=password)
            if user is not None:
                login(request, user)
                messages.success(request, f'Welcome back, {username}!')
                return redirect('home')
            else:
                messages.error(request, 'Invalid username or password.')
        else:
            messages.error(request, 'Invalid username or password.')
    else:
        form = AuthenticationForm()
    
    return render(request, 'auth/login.html', {'form': form})

@login_required
def profile(request):
    """User profile view"""
    if request.method == 'POST':
        form = UserProfileForm(request.POST, request.FILES, instance=request.user)
        if form.is_valid():
            form.save()
            messages.success(request, 'Profile updated successfully!')
            return redirect('profile')
    else:
        form = UserProfileForm(instance=request.user)
    
    return render(request, 'auth/profile.html', {'form': form})

@login_required
def change_password(request):
    """Password change view"""
    if request.method == 'POST':
        form = PasswordChangeForm(request.user, request.POST)
        if form.is_valid():
            user = form.save()
            update_session_auth_hash(request, user)
            messages.success(request, 'Your password was successfully updated!')
            return redirect('profile')
        else:
            messages.error(request, 'Please correct the error below.')
    else:
        form = PasswordChangeForm(request.user)
    
    return render(request, 'auth/change_password.html', {'form': form})

# Django Admin Customization (admin.py)
from django.contrib import admin
from django.contrib.auth.admin import UserAdmin
from .models import CustomUser, Post, Category, Comment

@admin.register(CustomUser)
class CustomUserAdmin(UserAdmin):
    """Custom user admin interface"""
    list_display = ('username', 'email', 'first_name', 'last_name', 'is_staff')
    list_filter = ('is_staff', 'is_superuser', 'is_active', 'groups')
    search_fields = ('username', 'first_name', 'last_name', 'email')
    ordering = ('username',)
    
    fieldsets = UserAdmin.fieldsets + (
        ('Additional Info', {
            'fields': ('bio', 'location', 'birth_date', 'profile_picture',
                      'website', 'twitter', 'github')
        }),
    )

@admin.register(Post)
class PostAdmin(admin.ModelAdmin):
    """Post admin interface"""
    list_display = ('title', 'author', 'status', 'published_date', 'created_date')
    list_filter = ('status', 'categories', 'created_date', 'published_date')
    search_fields = ('title', 'content', 'author__username')
    prepopulated_fields = {'slug': ('title',)}
    date_hierarchy = 'published_date'
    ordering = ('-published_date',)
    
    # Custom action
    actions = ['make_published']
    
    def make_published(self, request, queryset):
        """Custom admin action to publish selected posts"""
        updated = queryset.update(status='published')
        self.message_user(request, f'{updated} posts were successfully published.')
    make_published.short_description = "Mark selected posts as published"
    
    # Inline editing for comments
    class CommentInline(admin.TabularInline):
        model = Comment
        extra = 1
    
    inlines = [CommentInline]

@admin.register(Category)
class CategoryAdmin(admin.ModelAdmin):
    """Category admin interface"""
    list_display = ('name', 'post_count')
    search_fields = ('name',)
    prepopulated_fields = {'slug': ('name',)}
    
    def post_count(self, obj):
        return obj.posts.count()
    post_count.short_description = 'Number of Posts'

@admin.register(Comment)
class CommentAdmin(admin.ModelAdmin):
    """Comment admin interface"""
    list_display = ('author', 'post', 'created_date', 'approved')
    list_filter = ('approved', 'created_date')
    search_fields = ('author', 'content', 'post__title')
    actions = ['approve_comments']
    
    def approve_comments(self, request, queryset):
        """Custom admin action to approve comments"""
        queryset.update(approved=True)
        self.message_user(request, f'{queryset.count()} comments approved.')
    approve_comments.short_description = "Approve selected comments"

# Permission-based views
from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin

class StaffRequiredMixin(UserPassesTestMixin):
    """Mixin to require staff status"""
    def test_func(self):
        return self.request.user.is_staff

class SuperuserRequiredMixin(UserPassesTestMixin):
    """Mixin to require superuser status"""
    def test_func(self):
        return self.request.user.is_superuser

class AdminDashboardView(StaffRequiredMixin, ListView):
    """Admin dashboard view (staff only)"""
    model = Post
    template_name = 'admin/dashboard.html'
    
    def get_queryset(self):
        return Post.objects.all().select_related('author').prefetch_related('categories')
    
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['total_posts'] = Post.objects.count()
        context['published_posts'] = Post.objects.filter(status='published').count()
        context['total_comments'] = Comment.objects.count()
        context['pending_comments'] = Comment.objects.filter(approved=False).count()
        return context

Authentication & Admin Analysis

This Django authentication and admin example demonstrates:

Custom User Model: Extending Django's built-in User model
Authentication Views: Registration, login, and profile management
Form Handling: Custom forms for user registration and profile updates
Admin Customization: Customizing the Django admin interface
Permissions & Authorization: Controlling access with decorators and mixins
Admin Actions: Adding custom bulk actions to the admin
Inline Editing: Editing related models in the same admin page
Security: Proper password handling and session management

Key Takeaway: Django's authentication system and admin interface provide powerful, secure tools for user management and data administration with minimal configuration required.

Django Authentication & Admin Features:

User Model - Built-in or custom user models
Authentication - Login, logout, password management
Permissions - User and group-based permissions
Admin Interface - Automatic admin for data management
Admin Customization - Customizing admin appearance and behavior
Security - CSRF protection, password hashing, session security
Forms - User registration and profile forms
Middleware - Authentication middleware for request processing

Premium Content

REST APIS & DEPLOYMENT

Build REST APIs and deploy Django applications

Advanced

Module 6: Django REST APIs and Deployment

Django REST Framework (DRF) is a powerful toolkit for building Web APIs. Combined with proper deployment strategies, you can create robust, scalable web applications. This module covers API development, testing, and deployment to production environments.

Try It Yourself:

Python Code

# Django REST Framework and Deployment
# First, install Django REST Framework:
# pip install djangorestframework

# Add to INSTALLED_APPS in settings.py:
"""
INSTALLED_APPS = [
    ...
    'rest_framework',
    'rest_framework.authtoken',  # For token authentication
]
"""

# REST Framework Configuration (settings.py)
REST_FRAMEWORK = {
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.IsAuthenticatedOrReadOnly',
    ],
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework.authentication.SessionAuthentication',
        'rest_framework.authentication.TokenAuthentication',
    ],
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
    'PAGE_SIZE': 20,
    'DEFAULT_FILTER_BACKENDS': [
        'django_filters.rest_framework.DjangoFilterBackend',
        'rest_framework.filters.SearchFilter',
        'rest_framework.filters.OrderingFilter',
    ],
}

# Serializers (serializers.py)
from rest_framework import serializers
from .models import Post, Category, Comment, CustomUser

class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = CustomUser
        fields = ('id', 'username', 'email', 'first_name', 'last_name')
        read_only_fields = ('id',)

class CategorySerializer(serializers.ModelSerializer):
    post_count = serializers.ReadOnlyField()
    
    class Meta:
        model = Category
        fields = ('id', 'name', 'description', 'post_count', 'created_at')
        read_only_fields = ('id', 'post_count', 'created_at')

class CommentSerializer(serializers.ModelSerializer):
    author_name = serializers.CharField(source='author', read_only=True)
    
    class Meta:
        model = Comment
        fields = ('id', 'post', 'author_name', 'email', 'content', 
                 'created_date', 'approved')
        read_only_fields = ('id', 'created_date')

class PostSerializer(serializers.ModelSerializer):
    author = UserSerializer(read_only=True)
    categories = CategorySerializer(many=True, read_only=True)
    comments = CommentSerializer(many=True, read_only=True)
    excerpt = serializers.CharField(read_only=True)
    
    class Meta:
        model = Post
        fields = ('id', 'title', 'slug', 'content', 'excerpt', 'author',
                 'categories', 'status', 'published_date', 'created_date',
                 'updated_date', 'featured_image', 'comments')
        read_only_fields = ('id', 'slug', 'created_date', 'updated_date')

class PostCreateSerializer(serializers.ModelSerializer):
    class Meta:
        model = Post
        fields = ('title', 'content', 'categories', 'status', 'featured_image')
    
    def create(self, validated_data):
        # Set the author to the current user
        validated_data['author'] = self.context['request'].user
        return super().create(validated_data)

# API Views (api/views.py)
from rest_framework import viewsets, permissions, status
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework.parsers import MultiPartParser, FormParser
from django_filters.rest_framework import DjangoFilterBackend
from .models import Post, Category, Comment
from .serializers import (PostSerializer, PostCreateSerializer, 
                         CategorySerializer, CommentSerializer)

class CategoryViewSet(viewsets.ModelViewSet):
    """API endpoint for categories"""
    queryset = Category.objects.all()
    serializer_class = CategorySerializer
    permission_classes = [permissions.IsAuthenticatedOrReadOnly]
    filter_backends = [DjangoFilterBackend]
    filterset_fields = ['name']

class PostViewSet(viewsets.ModelViewSet):
    """API endpoint for posts"""
    queryset = Post.objects.filter(status='published').select_related('author').prefetch_related('categories', 'comments')
    permission_classes = [permissions.IsAuthenticatedOrReadOnly]
    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
    filterset_fields = ['categories', 'author', 'status']
    search_fields = ['title', 'content']
    ordering_fields = ['published_date', 'created_date', 'title']
    ordering = ['-published_date']
    parser_classes = [MultiPartParser, FormParser]
    
    def get_serializer_class(self):
        if self.action == 'create' or self.action == 'update':
            return PostCreateSerializer
        return PostSerializer
    
    def perform_create(self, serializer):
        serializer.save(author=self.request.user)
    
    @action(detail=True, methods=['post'], permission_classes=[permissions.IsAuthenticated])
    def like(self, request, pk=None):
        """Custom action to like a post"""
        post = self.get_object()
        # Implement like logic here
        return Response({'status': 'post liked'})
    
    @action(detail=False, methods=['get'])
    def recent(self, request):
        """Custom action to get recent posts"""
        recent_posts = self.get_queryset()[:5]
        serializer = self.get_serializer(recent_posts, many=True)
        return Response(serializer.data)

class CommentViewSet(viewsets.ModelViewSet):
    """API endpoint for comments"""
    queryset = Comment.objects.filter(approved=True)
    serializer_class = CommentSerializer
    permission_classes = [permissions.IsAuthenticatedOrReadOnly]
    filter_backends = [DjangoFilterBackend]
    filterset_fields = ['post', 'approved']
    
    def perform_create(self, serializer):
        serializer.save(author=self.request.user.username)

# API URLs (api/urls.py)
"""
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .api.views import CategoryViewSet, PostViewSet, CommentViewSet

router = DefaultRouter()
router.register(r'categories', CategoryViewSet)
router.register(r'posts', PostViewSet)
router.register(r'comments', CommentViewSet)

urlpatterns = [
    path('api/', include(router.urls)),
    path('api-auth/', include('rest_framework.urls')),
]
"""

# Production Settings (settings/production.py)
import os
from .base import *

DEBUG = False

ALLOWED_HOSTS = ['yourdomain.com', 'www.yourdomain.com', 'localhost']

# Database
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': os.environ.get('DB_NAME'),
        'USER': os.environ.get('DB_USER'),
        'PASSWORD': os.environ.get('DB_PASSWORD'),
        'HOST': os.environ.get('DB_HOST'),
        'PORT': os.environ.get('DB_PORT', '5432'),
    }
}

# Security settings
SECRET_KEY = os.environ.get('SECRET_KEY')
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
SECURE_SSL_REDIRECT = True
SECURE_HSTS_SECONDS = 31536000  # 1 year
SECURE_HSTS_INCLUDE_SUBDOMAINS = True
SECURE_HSTS_PRELOAD = True

# Static files
STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')
STATIC_URL = '/static/'

# Media files
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
MEDIA_URL = '/media/'

# Logging
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'file': {
            'level': 'ERROR',
            'class': 'logging.FileHandler',
            'filename': os.path.join(BASE_DIR, 'logs/django.log'),
        },
        'mail_admins': {
            'level': 'ERROR',
            'class': 'django.utils.log.AdminEmailHandler',
        }
    },
    'loggers': {
        'django': {
            'handlers': ['file', 'mail_admins'],
            'level': 'ERROR',
            'propagate': True,
        },
    },
}

# Caching
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.redis.RedisCache',
        'LOCATION': os.environ.get('REDIS_URL', 'redis://127.0.0.1:6379'),
    }
}

# Email configuration
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = os.environ.get('EMAIL_HOST')
EMAIL_PORT = os.environ.get('EMAIL_PORT', 587)
EMAIL_USE_TLS = True
EMAIL_HOST_USER = os.environ.get('EMAIL_HOST_USER')
EMAIL_HOST_PASSWORD = os.environ.get('EMAIL_HOST_PASSWORD')
DEFAULT_FROM_EMAIL = 'noreply@yourdomain.com'

# Deployment with Docker
"""
# Dockerfile
FROM python:3.11

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

RUN python manage.py collectstatic --noinput

EXPOSE 8000

CMD ["gunicorn", "myproject.wsgi:application", "--bind", "0.0.0.0:8000"]
"""

# Docker Compose
"""
# docker-compose.yml
version: '3.8'

services:
  web:
    build: .
    command: gunicorn myproject.wsgi:application --bind 0.0.0.0:8000
    volumes:
      - static_volume:/app/staticfiles
      - media_volume:/app/media
    expose:
      - 8000
    environment:
      - DEBUG=0
    depends_on:
      - db
      - redis

  db:
    image: postgres:13
    volumes:
      - postgres_data:/var/lib/postgresql/data/
    environment:
      - POSTGRES_DB=myproject
      - POSTGRES_USER=myprojectuser
      - POSTGRES_PASSWORD=myprojectpass

  redis:
    image: redis:6-alpine

  nginx:
    image: nginx:1.21-alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - static_volume:/app/staticfiles
      - media_volume:/app/media
    depends_on:
      - web

volumes:
  postgres_data:
  static_volume:
  media_volume:
"""

REST API & Deployment Analysis

This Django REST API and deployment example demonstrates:

Django REST Framework: Building powerful Web APIs with minimal code
Serializers: Converting complex data types to native Python datatypes
ViewSets: Handling common API patterns with view sets
Authentication & Permissions: Securing API endpoints
Filtering & Search: Implementing advanced query capabilities
Production Configuration: Security and performance settings for production
Docker Deployment: Containerizing Django applications
Environment Configuration: Managing settings across different environments

Key Takeaway: Django REST Framework extends Django's capabilities to create robust, secure APIs, while modern deployment practices ensure your applications are scalable, maintainable, and production-ready.

Django REST API & Deployment Features:

REST Framework - Powerful toolkit for building Web APIs
Serializers - Complex data type conversion
ViewSets & Routers - Consistent API URL patterns
Authentication - Token, session, and OAuth authentication
Permissions - Fine-grained access control
Production Deployment - Security and performance optimization
Containerization - Docker for consistent deployments
CI/CD - Automated testing and deployment pipelines

PRACTICE PLAYGROUND

Experiment with Django concepts

Your Django Playground: Try Your Own Django Code

Use this space to experiment with everything you've learned about Django web development. Try different models, views, templates, and API endpoints to see how they work. This is your sandbox to practice and explore the art of Django programming.

Python Code

# Django Playground - Try Your Own Code!

"""
Experiment with:
- Custom models and relationships
- Complex views and business logic
- Advanced template patterns
- API endpoints with Django REST Framework
- Authentication and authorization flows
- Your own creative ideas!
"""

# Example: E-commerce Models
from django.db import models
from django.contrib.auth.models import User
from django.core.validators import MinValueValidator, MaxValueValidator

class Product(models.Model):
    name = models.CharField(max_length=200)
    description = models.TextField()
    price = models.DecimalField(max_digits=10, decimal_places=2)
    stock = models.PositiveIntegerField(default=0)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    def __str__(self):
        return self.name
    
    def is_in_stock(self):
        return self.stock > 0

class Order(models.Model):
    STATUS_CHOICES = [
        ('pending', 'Pending'),
        ('processing', 'Processing'),
        ('shipped', 'Shipped'),
        ('delivered', 'Delivered'),
        ('cancelled', 'Cancelled'),
    ]
    
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    status = models.CharField(max_length=20, choices=STATUS_CHOICES, default='pending')
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    total_amount = models.DecimalField(max_digits=10, decimal_places=2, default=0)
    
    def calculate_total(self):
        total = sum(item.subtotal() for item in self.items.all())
        self.total_amount = total
        self.save()
        return total

class OrderItem(models.Model):
    order = models.ForeignKey(Order, related_name='items', on_delete=models.CASCADE)
    product = models.ForeignKey(Product, on_delete=models.CASCADE)
    quantity = models.PositiveIntegerField(default=1)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    
    def subtotal(self):
        return self.quantity * self.price

# Your experiments go here!
# Try creating:
# - Custom model methods
# - Complex queries
# - API views
# - Template filters
# - Form validation
# - Signal handlers
# - Custom management commands

print("Welcome to the Django Playground!")
print("Modify the code above to experiment with Django concepts.")

Code Analysis

Practice Ideas for Your Django Playground:

Django Development Challenges:

Complex Models: Implement e-commerce, social media, or CMS systems
Advanced Queries: Use Django's ORM for complex database operations
API Development: Build RESTful APIs with Django REST Framework
Authentication: Implement custom authentication backends
Performance: Optimize queries, caching, and database design

Sample Projects to Try:

Blog Platform: Complete blog with categories, tags, and comments
E-commerce Site: Product catalog, shopping cart, and order management
Social Network: User profiles, posts, likes, and follows
Task Manager: Project management with teams and deadlines
API Service: REST API for a mobile app or frontend framework

Remember: The key to mastering Django is practice and experimentation. Don't be afraid to try new things and make mistakes!

Advanced Django Challenges:

Implement complex applications:
- Multi-tenant SaaS application
- Real-time features with WebSockets
- Payment integration with Stripe or PayPal
- Search functionality with Elasticsearch
Create advanced API features:
- GraphQL API with Django
- Webhook implementations
- Rate limiting and throttling
- API versioning strategies
Build deployment pipelines:
- CI/CD with GitHub Actions
- Docker containerization
- Kubernetes deployment
- Multi-environment configuration
Practice performance optimization:
- Database query optimization
- Caching strategies with Redis
- Background tasks with Celery
- Static file optimization and CDN

Tips & Resources:

Start with simple projects and gradually increase complexity
Use version control (git) to track your progress
Read and understand the Django source code
Practice testing with Django's test framework
Study the Django documentation thoroughly
Join Django communities and contribute to open source

DJANGO FUNDAMENTALS

Learn the core concepts of Django web framework

Module 1: Django Fundamentals

Try It Yourself:

This Django setup demonstrates:

Key Django Concepts:

DJANGO MODELS

Master Django's Object-Relational Mapping system

Module 2: Django Models and Database

Try It Yourself:

This Django models example demonstrates:

Django Model Features:

VIEWS & URLS

Handle requests and define URL patterns

Module 3: Django Views and URL Configuration

Try It Yourself:

This Django views and URLs example demonstrates:

Django Views & URLs Features:

DJANGO TEMPLATES

Create dynamic HTML with Django template language

Module 4: Django Templates and Frontend

Try It Yourself:

This Django template example demonstrates:

Django Template Features:

AUTHENTICATION & ADMIN

Implement user authentication and admin interface

Module 5: Django Authentication and Admin

Try It Yourself:

This Django authentication and admin example demonstrates:

Django Authentication & Admin Features:

REST APIS & DEPLOYMENT

Build REST APIs and deploy Django applications

Module 6: Django REST APIs and Deployment

Try It Yourself:

This Django REST API and deployment example demonstrates:

Django REST API & Deployment Features:

PRACTICE PLAYGROUND

Experiment with Django concepts

Your Django Playground: Try Your Own Django Code

Practice Ideas for Your Django Playground:

Django Development Challenges:

Sample Projects to Try:

Advanced Django Challenges:

Tips & Resources:

Unlock Premium SkillMynte Django Content

Advanced Django Courses

Django Certification

Expert Mentorship

Monthly

Annual Best Value

Lifetime